home *** CD-ROM | disk | FTP | other *** search
/ Linux Cubed Series 8: LINUX Games / Linux Cubed Series 8 - LINUX Games.iso / games / actionrp / lrogue0.1 / lrogue0 / rogue / hit.c < prev    next >
C/C++ Source or Header  |  1992-02-05  |  8KB  |  418 lines
  1. /*
  2.  * hit.c
  3.  *
  4.  * This source herein may be modified and/or distributed by anybody who
  5.  * so desires, with the following restrictions:
  6.  *    1.)  No portion of this notice shall be removed.
  7.  *    2.)  Credit shall not be taken for the creation of this source.
  8.  *    3.)  This code is not to be traded, sold, or used for personal
  9.  *         gain or profit.
  10.  *
  11.  */
  12.  
  13. #ifndef CURSES
  14. #include <curses.h>
  15. #endif CURSES
  16. #include "rogue.h"
  17.  
  18. object *fight_monster = 0;
  19. boolean detect_monster;
  20. char hit_message[80] = "";
  21.  
  22. extern short halluc, blind, cur_level;
  23. extern short add_strength, ring_exp, r_rings;
  24. extern boolean being_held, interrupted, wizard;
  25.  
  26. mon_hit(monster, other, flame)
  27. register object *monster;
  28. char *other;
  29. boolean flame;
  30. {
  31.     short damage, hit_chance;
  32.     char *mn;
  33.     int minus;
  34.  
  35.     if (fight_monster && (monster != fight_monster)) {
  36.         fight_monster = 0;
  37.     }
  38.     monster->trow = NO_ROOM;
  39.     if (cur_level >= (AMULET_LEVEL * 2)) {
  40.         hit_chance = 100;
  41.     } else {
  42.         hit_chance = monster->m_hit_chance;
  43.         hit_chance -= (((2 * rogue.exp) + (2 * ring_exp)) - r_rings);
  44.     }
  45.     if (wizard) {
  46.         hit_chance /= 2;
  47.     }
  48.     if (!fight_monster) {
  49.         interrupted = 1;
  50.     }
  51.     mn = mon_name(monster);
  52.  
  53.     if (other) {
  54.         hit_chance -= ((rogue.exp + ring_exp) - r_rings);
  55.     }
  56.  
  57.     if (!rand_percent(hit_chance)) {
  58.         if (!fight_monster) {
  59.             sprintf(hit_message + strlen(hit_message),
  60.             "the %s misses", (other ? other : mn));
  61.             message(hit_message, 1);
  62.             hit_message[0] = 0;
  63.         }
  64.         return;
  65.     }
  66.     if (!fight_monster) {
  67.         sprintf(hit_message + strlen(hit_message), "the %s hit",
  68.             (other ? other : mn));
  69.         message(hit_message, 1);
  70.         hit_message[0] = 0;
  71.     }
  72.     if (!(monster->m_flags & STATIONARY)) {
  73.         damage = get_damage(monster->m_damage, 1);
  74.         if (other) {
  75.             if (flame) {
  76.                 if ((damage -= get_armor_class(rogue.armor)) < 0) {
  77.                     damage = 1;
  78.                 }
  79.             }
  80.         }
  81.         if (cur_level >= (AMULET_LEVEL * 2)) {
  82.             minus =  ((AMULET_LEVEL * 2) - cur_level);
  83.         } else {
  84.             minus = get_armor_class(rogue.armor) * 3.00;
  85.             minus = minus/100 *  damage;
  86.         }
  87.         damage -= (short) minus;
  88.     } else {
  89.         damage = monster->stationary_damage++;
  90.     }
  91.     if (wizard) {
  92.         damage /= 3;
  93.     }
  94.     if (damage > 0) {
  95.         rogue_damage(damage, monster);
  96.     }
  97.     if (monster->m_flags & SPECIAL_HIT) {
  98.         special_hit(monster);
  99.     }
  100. }
  101.  
  102. rogue_hit(monster, force_hit)
  103. register object *monster;
  104. boolean force_hit;
  105. {
  106.     short damage, hit_chance;
  107.  
  108.     if (monster) {
  109.         if (check_imitator(monster)) {
  110.             return;
  111.         }
  112.         hit_chance = force_hit ? 100 : get_hit_chance(rogue.weapon);
  113.  
  114.         if (wizard) {
  115.             hit_chance *= 2;
  116.         }
  117.         if (!rand_percent(hit_chance)) {
  118.             if (!fight_monster) {
  119.                 (void) strcpy(hit_message, "you miss  ");
  120.             }
  121.             goto RET;
  122.         }
  123.         damage = get_weapon_damage(rogue.weapon);
  124.         if (wizard) {
  125.             damage *= 3;
  126.         }
  127.         if (mon_damage(monster, damage)) {    /* still alive? */
  128.             if (!fight_monster) {
  129.                 (void) strcpy(hit_message, "you hit  ");
  130.             }
  131.         }
  132. RET:    check_gold_seeker(monster);
  133.         wake_up(monster);
  134.     }
  135. }
  136.  
  137. rogue_damage(d, monster)
  138. short d;
  139. object *monster;
  140. {
  141.     if (d >= rogue.hp_current) {
  142.         rogue.hp_current = 0;
  143.         print_stats(STAT_HP);
  144.         killed_by(monster, 0);
  145.     }
  146.     rogue.hp_current -= d;
  147.     print_stats(STAT_HP);
  148. }
  149.  
  150. get_damage(ds, r)
  151. char *ds;
  152. boolean r;
  153. {
  154.     register i = 0, j, n, d, total = 0;
  155.  
  156.     while (ds[i]) {
  157.         n = get_number(ds+i);
  158.         while (ds[i++] != 'd') ;
  159.         d = get_number(ds+i);
  160.         while ((ds[i] != '/') && ds[i]) i++;
  161.  
  162.         for (j = 0; j < n; j++) {
  163.             if (r) {
  164.                 total += get_rand(1, d);
  165.             } else {
  166.                 total += d;
  167.             }
  168.         }
  169.         if (ds[i] == '/') {
  170.             i++;
  171.         }
  172.     }
  173.     return(total);
  174. }
  175.  
  176. get_w_damage(obj)
  177. object *obj;
  178. {
  179.     char new_damage[12];
  180.     register to_hit, damage;
  181.     register i = 0;
  182.  
  183.     if ((!obj) || (obj->what_is != WEAPON)) {
  184.         return(-1);
  185.     }
  186.     to_hit = get_number(obj->damage) + obj->hit_enchant;
  187.     while (obj->damage[i++] != 'd') ;
  188.     damage = get_number(obj->damage + i) + obj->d_enchant;
  189.  
  190.     sprintf(new_damage, "%dd%d", to_hit, damage);
  191.  
  192.     return(get_damage(new_damage, 1));
  193. }
  194.  
  195. get_number(s)
  196. register char *s;
  197. {
  198.     register i = 0;
  199.     register total = 0;
  200.  
  201.     while ((s[i] >= '0') && (s[i] <= '9')) {
  202.         total = (10 * total) + (s[i] - '0');
  203.         i++;
  204.     }
  205.     return(total);
  206. }
  207.  
  208. long
  209. lget_number(s)
  210. register char *s;
  211. {
  212.     register long i = 0;
  213.     register long total = 0;
  214.  
  215.     while ((s[i] >= '0') && (s[i] <= '9')) {
  216.         total = (10 * total) + (s[i] - '0');
  217.         i++;
  218.     }
  219.     return(total);
  220. }
  221.  
  222. to_hit(obj)
  223. object *obj;
  224. {
  225.     if (!obj) {
  226.         return(1);
  227.     }
  228.     return(get_number(obj->damage) + obj->hit_enchant);
  229. }
  230.  
  231. damage_for_strength()
  232. {
  233.     short strength;
  234.  
  235.     strength = rogue.str_current + add_strength;
  236.  
  237.     if (strength <= 6) {
  238.         return(strength-5);
  239.     }
  240.     if (strength <= 14) {
  241.         return(1);
  242.     }
  243.     if (strength <= 17) {
  244.         return(3);
  245.     }
  246.     if (strength <= 18) {
  247.         return(4);
  248.     }
  249.     if (strength <= 20) {
  250.         return(5);
  251.     }
  252.     if (strength <= 21) {
  253.         return(6);
  254.     }
  255.     if (strength <= 30) {
  256.         return(7);
  257.     }
  258.     return(8);
  259. }
  260.  
  261. mon_damage(monster, damage)
  262. object *monster;
  263. {
  264.     char *mn;
  265.     short row, col;
  266.  
  267.     monster->hp_to_kill -= damage;
  268.  
  269.     if (monster->hp_to_kill <= 0) {
  270.         row = monster->row;
  271.         col = monster->col;
  272.         dungeon[row][col] &= ~MONSTER;
  273.         mvaddch(row, col, (int) get_dungeon_char(row, col));
  274.  
  275.         fight_monster = 0;
  276.         cough_up(monster);
  277.         mn = mon_name(monster);
  278.         sprintf(hit_message+strlen(hit_message), "defeated the %s", mn);
  279.         message(hit_message, 1);
  280.         hit_message[0] = 0;
  281.         add_exp(monster->kill_exp, 1);
  282.         take_from_pack(monster, &level_monsters);
  283.  
  284.         if (monster->m_flags & HOLDS) {
  285.             being_held = 0;
  286.         }
  287.         free_object(monster);
  288.         return(0);
  289.     }
  290.     return(1);
  291. }
  292.  
  293. fight(to_the_death)
  294. boolean to_the_death;
  295. {
  296.     short ch, c;
  297.     short row, col;
  298.     boolean first_miss = 1;
  299.     short possible_damage;
  300.     object *monster;
  301.  
  302.     while (!is_direction(ch = rgetchar())) {
  303.         sound_bell();
  304.         if (first_miss) {
  305.             message("direction?", 0);
  306.             first_miss = 0;
  307.         }
  308.     }
  309.     check_message();
  310.     if (ch == CANCEL) {
  311.         return;
  312.     }
  313.     row = rogue.row; col = rogue.col;
  314.     get_dir_rc(ch, &row, &col, 0);
  315.  
  316.     c = mvinch(row, col);
  317.     if (((c < 'A') || (c > 'Z')) ||
  318.         (!can_move(rogue.row, rogue.col, row, col))) {
  319.         message("I see no monster there", 0);
  320.         return;
  321.     }
  322.     if (!(fight_monster = object_at(&level_monsters, row, col))) {
  323.         return;
  324.     }
  325.     if (!(fight_monster->m_flags & STATIONARY)) {
  326.         possible_damage = ((get_damage(fight_monster->m_damage, 0) * 2) / 3);
  327.     } else {
  328.         possible_damage = fight_monster->stationary_damage - 1;
  329.     }
  330.     while (fight_monster) {
  331.         (void) one_move_rogue(ch, 0);
  332.         if (((!to_the_death) && (rogue.hp_current <= possible_damage)) ||
  333.             interrupted || (!(dungeon[row][col] & MONSTER))) {
  334.             fight_monster = 0;
  335.         } else {
  336.             monster = object_at(&level_monsters, row, col);
  337.             if (monster != fight_monster) {
  338.                 fight_monster = 0;
  339.             }
  340.         }
  341.     }
  342. }
  343.  
  344. get_dir_rc(dir, row, col, allow_off_screen)
  345. short dir;
  346. short *row, *col;
  347. short allow_off_screen;
  348. {
  349.     switch(dir) {
  350.     case 'h':
  351.         if (allow_off_screen || (*col > 0)) {
  352.             (*col)--;
  353.         }
  354.         break;
  355.     case 'j':
  356.         if (allow_off_screen || (*row < (DROWS-2))) {
  357.             (*row)++;
  358.         }
  359.         break;
  360.     case 'k':
  361.         if (allow_off_screen || (*row > MIN_ROW)) {
  362.             (*row)--;
  363.         }
  364.         break;
  365.     case 'l':
  366.         if (allow_off_screen || (*col < (DCOLS-1))) {
  367.             (*col)++;
  368.         }
  369.         break;
  370.     case 'y':
  371.         if (allow_off_screen || ((*row > MIN_ROW) && (*col > 0))) {
  372.             (*row)--;
  373.             (*col)--;
  374.         }
  375.         break;
  376.     case 'u':
  377.         if (allow_off_screen || ((*row > MIN_ROW) && (*col < (DCOLS-1)))) {
  378.             (*row)--;
  379.             (*col)++;
  380.         }
  381.         break;
  382.     case 'n':
  383.         if (allow_off_screen || ((*row < (DROWS-2)) && (*col < (DCOLS-1)))) {
  384.             (*row)++;
  385.             (*col)++;
  386.         }
  387.         break;
  388.     case 'b':
  389.         if (allow_off_screen || ((*row < (DROWS-2)) && (*col > 0))) {
  390.             (*row)++;
  391.             (*col)--;
  392.         }
  393.         break;
  394.     }
  395. }
  396.  
  397. get_hit_chance(weapon)
  398. object *weapon;
  399. {
  400.     short hit_chance;
  401.  
  402.     hit_chance = 40;
  403.     hit_chance += 3 * to_hit(weapon);
  404.     hit_chance += (((2 * rogue.exp) + (2 * ring_exp)) - r_rings);
  405.     return(hit_chance);
  406. }
  407.  
  408. get_weapon_damage(weapon)
  409. object *weapon;
  410. {
  411.     short damage;
  412.  
  413.     damage = get_w_damage(weapon);
  414.     damage += damage_for_strength();
  415.     damage += ((((rogue.exp + ring_exp) - r_rings) + 1) / 2);
  416.     return(damage);
  417. }
  418.